<template>
    <div v-if="yongshenStr" class="thys-block">
        <div class="thys-block-title">
            调候用神提示：
            <span class="thys-block-title_span">{{ yongshenStr }}</span>
        </div>
        <div class="thys-block-tips">
            本八字：
            <span v-if="touStr" class="thys-block-tips-text1">{{ touStr }}</span>
            <span 
                v-for="(gan, index) in touGans" 
                :key="`tou-${index}`"
                class="thys-block-tips-text2"
            >
                {{ gan }}
            </span>
            <span v-if="cangStr" class="thys-block-tips-text1">{{ cangStr }}</span>
            <span 
                v-for="(gan, index) in cangGans" 
                :key="`cang-${index}`"
                class="thys-block-tips-text2"
            >
                {{ gan }}
            </span>
        </div>
    </div>
</template>

<script setup lang="ts">
import { computed } from 'vue'

interface Props {
    bazi: string // 八字字符串，格式：年干年支月干月支日干日支时干时支
    zanggan: Array<Array<{ stem: string }>> // 藏干数组，每个元素是一个柱的藏干数组
}

const props = defineProps<Props>()

// 调候用神字典初始化
const thysInit = (): Record<string, string> => {
    const thysDict: Record<string, string> = {}
    const thysDataStr =
        '丙 癸,丙 癸,壬 庚,庚 甲,丙 甲 癸,丙 庚 甲,戊 甲 壬 丙 丁,己 壬 庚,庚 丙 戊,辛 丙\n' +
        '庚 丙 丁 戊 己,丙 癸,壬 己,庚 甲,丙 甲 癸,甲 丙 癸,丁 甲 庚 丙,壬 甲,庚 辛 戊,庚 辛\n' +
        '庚 丁 壬,癸 丙 戊,壬 甲,甲 庚,甲 丙 癸,丙 癸 甲,甲 丁 壬 癸,壬 甲,甲 庚,丙 辛 甲\n' +
        '癸 庚 丁,癸,壬 癸 庚,甲 庚,甲 丙 癸,癸 丙,壬 戊 丙 丁,壬 甲 癸,壬 辛 庚 癸,辛\n' +
        '癸 庚 丁,癸 丙,壬 庚,壬 癸 庚,壬 甲 丙,癸 丙,壬 癸,壬 己 癸,癸 庚 辛,庚 辛 壬 癸\n' +
        '癸 庚 丁,癸 丙,壬 庚,甲 壬 庚,癸 丙 甲,癸 丙,丁 甲,壬 庚 甲,辛 甲,庚 辛 壬 癸\n' +
        '庚 丁 壬,丙 癸 己,壬 戊,甲 丙 庚 戊,丙 癸 甲,丙 癸,丁 甲,壬 甲 戊,戊 丁,丁\n' +
        '庚 丁 丙,癸 丙 丁,壬 癸,甲 丙 庚 戊,丙 癸,丙 癸,丁 甲 丙,壬 甲,甲 庚,辛 丙\n' +
        '庚 甲 丁 壬 癸,癸 辛,甲 壬,甲 戊 庚,甲 丙 癸,甲 丙 癸,甲 壬,壬 甲,甲 丙,辛 甲 壬 癸\n' +
        '庚 丁 丙 戊,丙 戊,甲 戊 庚 壬,甲 庚,甲 丙,丙 甲 戊,丁 丙,壬 丙,戊 丙 庚,庚 辛 戊 丁\n' +
        '丁 庚 丙,丙,壬 戊 己,甲 庚,丙 甲,丙 甲 戊,丁 甲 丙,丙 戊 壬 甲,戊 丙,丙 辛\n' +
        '丁 庚 丙,丙,壬 甲,甲 庚,丙 甲,丙 甲 戊,丁 甲 丙,丙 壬 戊 己,丙 甲 丁,丙 丁'

    const tian_gan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
    const di_zhi = ['寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥', '子', '丑']

    const arr1 = thysDataStr.split('\n')
    for (let i = 0; i < arr1.length; i++) {
        const arr2 = arr1[i].split(',')
        for (let j = 0; j < arr2.length; j++) {
            thysDict[tian_gan[j] + di_zhi[i]] = arr2[j]
        }
    }

    return thysDict
}

// 调候用神字典
const thysDict = thysInit()

// 计算调候用神字符串
const yongshenStr = computed(() => {
    if (!props.bazi || props.bazi.length < 8) return ''
    
    // 日干+月支：bazi[4]是日干，bazi[3]是月支
    const dayStem = props.bazi[4]
    const monthBranch = props.bazi[3]
    
    if (!dayStem || !monthBranch) return ''
    
    const key = dayStem + monthBranch
    return thysDict[key] || ''
})

// 计算"透"（用神中的天干是否在年干、月干、时干中）
const touGans = computed(() => {
    if (!yongshenStr.value) return []
    
    const yongshenArr = yongshenStr.value.split(' ').filter(Boolean)
    const touarr: string[] = []
    
    // 检查年干、月干、时干（索引0, 2, 6）
    const indexarr = [0, 2, 6]
    const checked = new Set<string>()
    
    for (const index of indexarr) {
        if (index >= props.bazi.length) continue
        const gan = props.bazi[index]
        if (!gan) continue
        
        for (const yongshenGan of yongshenArr) {
            if (gan === yongshenGan && !checked.has(yongshenGan)) {
                touarr.push(yongshenGan)
                checked.add(yongshenGan)
            }
        }
    }
    
    return touarr
})

// 计算"透"字符串
const touStr = computed(() => {
    return touGans.value.length > 0 ? '透' : ''
})

// 计算"藏"（用神中的天干是否在藏干中）
const cangGans = computed(() => {
    if (!yongshenStr.value) return []
    
    const yongshenArr = yongshenStr.value.split(' ').filter(Boolean)
    const cangarr: string[] = []
    const checked = new Set<string>()
    
    // 遍历所有藏干
    for (const pillarZanggan of props.zanggan) {
        if (!Array.isArray(pillarZanggan)) continue
        
        for (const zang of pillarZanggan) {
            const zangStem = zang?.stem
            if (!zangStem) continue
            
            for (const yongshenGan of yongshenArr) {
                if (zangStem === yongshenGan && !checked.has(yongshenGan)) {
                    cangarr.push(yongshenGan)
                    checked.add(yongshenGan)
                }
            }
        }
    }
    
    return cangarr
})

// 计算"藏"字符串
const cangStr = computed(() => {
    return cangGans.value.length > 0 ? '藏' : ''
})
</script>

<style scoped>
.thys-block {
    margin: 16px 0;
    padding: 0;
}

.thys-block-title {
    font-size: 14px;
    color: #64748b;
    font-weight: 500;
    margin-bottom: 8px;
}

.thys-block-title_span {
    color: #1e293b;
    font-weight: 600;
    margin-left: 4px;
}

.thys-block-tips {
    font-size: 14px;
    color: #64748b;
    font-weight: 400;
    line-height: 1.6;
}

.thys-block-tips-text1 {
    color: #64748b;
    font-weight: 500;
    margin: 0 4px;
}

.thys-block-tips-text2 {
    color: #1e293b;
    font-weight: 500;
    margin: 0 2px;
}
</style>
